package com.dolphin.aiagentplatform.utils;

import com.dolphin.aiagentplatform.model.vo.user.UserVO;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;

import java.util.LinkedHashMap;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 * 提供常用的Redis操作方法
 */
@Slf4j
@Component
public class RedisUtils {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 用户登录信息的Redis key前缀
     */
    public static final String USER_TOKEN_KEY_PREFIX = "user:token:";

    /**
     * 默认缓存过期时间（30分钟）
     */
    private static final long DEFAULT_EXPIRE = 30L;

    /**
     * 存入缓存
     *
     * @param key   键
     * @param value 值
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
        log.debug("Redis SET: {}", key);
    }

    /**
     * 存入缓存并设置过期时间
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间（分钟）
     */
    public void set(String key, Object value, long expire) {
        redisTemplate.opsForValue().set(key, value, expire, TimeUnit.MINUTES);
        log.debug("Redis SET with expire: {}, 过期时间: {}分钟", key, expire);
    }

    /**
     * 获取缓存
     *
     * @param key 键
     * @return 缓存值
     */
    public Object get(String key) {
        Object value = redisTemplate.opsForValue().get(key);
        if (value == null) {
            log.debug("Redis GET: {} -> null (不存在)", key);
        } else {
            log.debug("Redis GET: {} -> {}", key, value.getClass().getSimpleName());
        }
        return value;
    }

    /**
     * 删除缓存
     *
     * @param key 键
     * @return 是否成功
     */
    public boolean delete(String key) {
        boolean result = Boolean.TRUE.equals(redisTemplate.delete(key));
        log.debug("Redis DELETE: {} -> {}", key, result);
        return result;
    }

    /**
     * 设置过期时间
     *
     * @param key    键
     * @param expire 过期时间（分钟）
     * @return 是否成功
     */
    public boolean expire(String key, long expire) {
        boolean result = Boolean.TRUE.equals(redisTemplate.expire(key, expire, TimeUnit.MINUTES));
        log.debug("Redis EXPIRE: {}, 设置为{}分钟, 结果: {}", key, expire, result);
        return result;
    }

    /**
     * 检查key是否存在
     *
     * @param key 键
     * @return 是否存在
     */
    public boolean hasKey(String key) {
        boolean result = Boolean.TRUE.equals(redisTemplate.hasKey(key));
        log.debug("Redis EXISTS: {} -> {}", key, result);
        return result;
    }

    /**
     * 获取缓存过期时间
     *
     * @param key 键
     * @return 过期时间（秒）
     */
    public long getExpire(String key) {
        long expire = redisTemplate.getExpire(key, TimeUnit.SECONDS);
        log.debug("Redis TTL: {} -> {}秒", key, expire);
        return expire;
    }

    /**
     * 存储用户Token
     * 
     * @param token JWT令牌
     * @param value 用户信息
     */
    public void setUserToken(String token, Object value) {
        String key = USER_TOKEN_KEY_PREFIX + token;
        set(key, value, DEFAULT_EXPIRE);
        log.debug("保存用户令牌: {}, 类型: {}", key, value.getClass().getName());
    }

    /**
     * 获取用户Token信息
     *
     * @param token JWT令牌
     * @return 用户信息
     */
    public UserVO getUserToken(String token) {
        String key = USER_TOKEN_KEY_PREFIX + token;
        Object value = get(key);
        if (value != null) {
            if (value instanceof LinkedHashMap) {
                // 将LinkedHashMap转换为UserVO
                ObjectMapper objectMapper = new ObjectMapper();
                return objectMapper.convertValue(value, UserVO.class);
            } else if (value instanceof UserVO) {
                return (UserVO) value;
            }
            log.debug("获取用户令牌: {}, 类型: {}", key, value.getClass().getName());
        } else {
            log.debug("获取用户令牌: {} -> null", key);
        }
        return null;
    }

    /**
     * 删除用户Token
     * 
     * @param token JWT令牌
     * @return 是否成功
     */
    public boolean deleteUserToken(String token) {
        String key = USER_TOKEN_KEY_PREFIX + token;
        return delete(key);
    }

    /**
     * 刷新用户Token过期时间
     * 
     * @param token JWT令牌
     * @return 是否成功
     */
    public boolean refreshUserToken(String token) {
        String key = USER_TOKEN_KEY_PREFIX + token;
        boolean result = expire(key, DEFAULT_EXPIRE);
        log.debug("刷新用户令牌过期时间: {} -> {}", key, result);
        return result;
    }
} 